// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV })
const db = cloud.database()
const _ = db.command // 获取数据库操作符

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const { check } = event
  
  try {
    console.log('接收到评分数据:', check)
    
    // 检查是否接收到有效的 OPENID
    if (!wxContext || !wxContext.OPENID) {
      return {
        success: false,
        error: '无法获取用户信息'
      }
    }
    
    // 开发阶段：直接从客户端传递的数据中获取角色信息
    if (check.userRole) {
      console.log('使用客户端传递的角色信息:', check.userRole);
      // 直接使用客户端传递的角色进行权限检查
      if (check.userRole !== '宿管' && check.userRole !== '管理员') {
        return {
          success: false,
          error: '无权进行评分，只有宿管或管理员可以评分'
        }
      }
    } else {
      // 生产环境仍保留数据库检查逻辑
      // 检查是否有权限进行评分
      const openid = wxContext.OPENID;
      
      // 先检查用户是否存在
      let userInfo;
      try {
        userInfo = await db.collection('users').where({
          openid: openid
        }).get();
        
        console.log('查询到的用户信息:', userInfo);
      } catch (queryErr) {
        console.error('查询用户信息失败:', queryErr);
        return {
          success: false,
          error: '查询用户信息失败: ' + (queryErr.message || '未知错误')
        }
      }
      
      // 检查用户是否存在且是宿管
      if (!userInfo || !userInfo.data || userInfo.data.length === 0) {
        return {
          success: false,
          error: '用户不存在，请先登录'
        }
      }
      
      if (userInfo.data[0].role !== '宿管' && userInfo.data[0].role !== '管理员') {
        return {
          success: false,
          error: '无权进行评分，只有宿管或管理员可以评分'
        }
      }
    }
    
    // 检查check对象是否完整
    if (!check || !check.dormId) {
      return {
        success: false,
        error: '提交的评分数据不完整，缺少宿舍ID'
      }
    }
    
    if (!check.totalScore && check.totalScore !== 0) {
      return {
        success: false,
        error: '提交的评分数据不完整，缺少总分'
      }
    }
    
    // 检查寝室是否存在
    let dormInfo;
    try {
      dormInfo = await db.collection('dorms').doc(check.dormId).get();
      console.log('查询到的宿舍信息:', dormInfo);
    } catch (dormErr) {
      console.error('查询宿舍信息失败:', dormErr);
      return {
        success: false,
        error: '查询宿舍信息失败: ' + (dormErr.message || '未知错误')
      }
    }
    
    if (!dormInfo || !dormInfo.data) {
      return {
        success: false,
        error: '寝室不存在'
      }
    }

    const fiveSecondsAgo = new Date(Date.now() - 5000);
       const existingCheck = await db.collection('checks')
         .where({
           dormId: check.dormId,
           checkerId: wxContext.OPENID,
           totalScore: check.totalScore, // 检查分数是否也相同
           createTime: _.gt(fiveSecondsAgo)
         })
         .orderBy('createTime', 'desc') // 获取最新的一个
         .limit(1)
         .get();

       if (existingCheck.data && existingCheck.data.length > 0) {
         console.log('检测到重复提交:', existingCheck.data[0]);
         return {
           success: false,
           error: '检测到重复提交，请勿在短时间内重复操作。',
           isDuplicate: true // 可以给前端一个明确的重复标记
         };
       }
    
    // 确保数据完整性
    // 构建要存入数据库的 checkData
    const checkDataToSave = {
      ...check, // event.check，从客户端传来，会包含 showcaseImageFileIDs (如果客户端传了)
      dormId: check.dormId, // 确保 dormId
      building: check.building || dormInfo.data.building || '',
      roomNo: check.roomNo || dormInfo.data.roomNo || '',
      checkerId: wxContext.OPENID, // 确保检查人ID已记录
      checkerName: check.userName || '开发测试用户', // 开发阶段使用传递的用户名
      checkDate: check.checkDate ? new Date(check.checkDate) : new Date(), // 确保是Date对象
      createTime: new Date(),
      updateTime: new Date(),
      // 如果客户端没有传 showcaseImageFileIDs，则默认为空数组
      showcaseImageFileIDs: check.showcaseImageFileIDs && Array.isArray(check.showcaseImageFileIDs) ? check.showcaseImageFileIDs : []
    };
    
    // 移除可能存在的客户端传来的 _id，防止与数据库冲突
    delete checkDataToSave._id;

    // 保存检查记录
    let checkResult;
    try {
      checkResult = await db.collection('checks').add({
        data: checkDataToSave
      });
      console.log('检查记录保存成功:', checkResult);
    } catch (addErr) {
      console.error('保存检查记录失败:', addErr);
      return {
        success: false,
        error: '保存检查记录失败: ' + (addErr.message || '未知错误')
      }
    }
    
    // 更新宿舍当前分数和最后检查时间等信息
    try {
      const historyItem = {
        checkId: checkResult._id,
        date: checkDataToSave.checkDate,
        score: check.totalScore,
        checkerId: wxContext.OPENID,
        checkerName: check.userName || '开发测试用户'
      };
      
      await db.collection('dorms').doc(check.dormId).update({
        data: {
          currentScore: check.totalScore,
          lastCheckTime: checkDataToSave.checkDate,
          lastCheckId: checkResult._id,
          updateTime: new Date(),
          scoreHistory: _.push({
            each: [historyItem],
            position: 0,
            slice: 10
          })
        }
      });
      console.log('更新宿舍分数和历史记录成功');
    } catch (updateErr) {
      console.error('更新宿舍数据失败:', updateErr);
      // 更新失败时回滚检查记录
      try {
        await db.collection('checks').doc(checkResult._id).remove();
        console.log('回滚检查记录成功');
      } catch (removeErr) {
        console.error('回滚检查记录失败:', removeErr);
      }
      return {
        success: false,
        error: '更新宿舍分数失败: ' + (updateErr.message || '未知错误')
      };
    }

    // 在宿舍分数等信息更新成功后，处理优秀宿舍图片的逻辑
    if (checkDataToSave.showcaseImageFileIDs && checkDataToSave.showcaseImageFileIDs.length > 0) {
      try {
        await db.collection('dorms').doc(check.dormId).update({
          data: {
            showcaseImages: checkDataToSave.showcaseImageFileIDs,
            updateTime: new Date()
          }
        });
        console.log('优秀宿舍展示图片 FileIDs 更新到宿舍记录成功。');
      } catch (updateShowcaseErr) {
        console.error('更新宿舍展示图片 FileIDs 失败:', updateShowcaseErr);
      
      }
    }
    
    // 如果分数低于某个阈值（例如60），调用cleanupAndResetTasks来处理相关任务

    const lowScoreThreshold = 60; 
    if (check.totalScore < lowScoreThreshold) {
      try {
        const checkDataForTask = {
          ...checkDataToSave, // 使用已保存到数据库的检查数据
          _id: checkResult._id, // 确保使用已生成的检查记录ID
        };

        console.log('调用 cleanupAndResetTasks，参数 checkDataForTask:', checkDataForTask);
        await cloud.callFunction({
          name: 'cleanupAndResetTasks',
          data: {
            dormId: check.dormId,
            checkData: checkDataForTask
          }
        })
        console.log('cleanupAndResetTasks 调用成功。');
      } catch (taskErr) {
        console.error('调用 cleanupAndResetTasks 失败:', taskErr);
        // 任务处理失败不影响主流程，但应记录
      }
    }
    
    return {
      success: true,
      checkId: checkResult._id,
      message: '评分提交成功'
    }
    
  } catch (e) {
    console.error('云函数执行出错:', e)
    return {
      success: false,
      error: e.message || '云函数未知错误'
    }
  }
} 